home *** CD-ROM | disk | FTP | other *** search
/ Champak 40 / Vol 40.iso / games / ufo_comm.swf / scripts / DefineButton2_254 / BUTTONCONDACTION on(release).as
Encoding:
Text File  |  2007-04-25  |  79.3 KB  |  1,770 lines

  1. on(release){
  2.    var ┬º\x01┬º = 494;
  3.    loop0:
  4.    while(true)
  5.    {
  6.       if(eval("\x01") == 494)
  7.       {
  8.          set("\x01",eval("\x01") - 257);
  9.          ┬º┬ºpush(true);
  10.          continue;
  11.       }
  12.       if(eval("\x01") == 732)
  13.       {
  14.          set("\x01",eval("\x01") + 176);
  15.          if(┬º┬ºpop())
  16.          {
  17.             set("\x01",eval("\x01") + 3);
  18.          }
  19.          continue;
  20.       }
  21.       if(eval("\x01") == 853)
  22.       {
  23.          set("\x01",eval("\x01") - 637);
  24.          break;
  25.       }
  26.       if(eval("\x01") == 237)
  27.       {
  28.          set("\x01",eval("\x01") + 627);
  29.          if(┬º┬ºpop())
  30.          {
  31.             set("\x01",eval("\x01") - 794);
  32.          }
  33.          continue;
  34.       }
  35.       if(eval("\x01") == 806)
  36.       {
  37.          set("\x01",eval("\x01") + 116);
  38.          if(┬º┬ºpop())
  39.          {
  40.             set("\x01",eval("\x01") - 413);
  41.          }
  42.          continue;
  43.       }
  44.       if(eval("\x01") == 975)
  45.       {
  46.          set("\x01",eval("\x01") - 416);
  47.          if(┬º┬ºpop())
  48.          {
  49.             set("\x01",eval("\x01") - 456);
  50.          }
  51.          continue;
  52.       }
  53.       if(eval("\x01") == 216)
  54.       {
  55.          set("\x01",eval("\x01") + 619);
  56.          getUrl("http://www.onlinegameshq.com", "_blank");
  57.          break;
  58.       }
  59.       if(eval("\x01") == 862)
  60.       {
  61.          set("\x01",eval("\x01") - 130);
  62.          ┬º┬ºpush(true);
  63.          continue;
  64.       }
  65.       if(eval("\x01") == 509)
  66.       {
  67.          set("\x01",eval("\x01") + 466);
  68.          ┬º┬ºpush(true);
  69.          continue;
  70.       }
  71.       if(eval("\x01") == 70)
  72.       {
  73.          set("\x01",eval("\x01") + 284);
  74.          ┬º┬ºpush(true);
  75.          continue;
  76.       }
  77.       if(eval("\x01") == 783)
  78.       {
  79.          set("\x01",eval("\x01") - 485);
  80.          ┬º┬ºpush(true);
  81.          continue;
  82.       }
  83.       if(eval("\x01") == 864)
  84.       {
  85.          set("\x01",eval("\x01") - 794);
  86.          loop1:
  87.          while(true)
  88.          {
  89.             set(┬º┬ºpop(),┬º┬ºpop());
  90.             if(┬º┬ºpop())
  91.             {
  92.                set("\x01",eval("\x01") + 162);
  93.             }
  94.             while(true)
  95.             {
  96.                if(eval("\x01") == 163)
  97.                {
  98.                   set("\x01",eval("\x01") + 484);
  99.                   ┬º┬ºpush(true);
  100.                }
  101.                else if(eval("\x01") == 157)
  102.                {
  103.                   set("\x01",eval("\x01") + 518);
  104.                   ┬º┬ºpush(true);
  105.                }
  106.                else
  107.                {
  108.                   if(eval("\x01") == 56)
  109.                   {
  110.                      set("\x01",eval("\x01") + 101);
  111.                      break loop0;
  112.                   }
  113.                   if(eval("\x01") == 185)
  114.                   {
  115.                      set("\x01",eval("\x01") + 796);
  116.                      break loop0;
  117.                   }
  118.                   if(eval("\x01") == 653)
  119.                   {
  120.                      break;
  121.                   }
  122.                   if(eval("\x01") == 248)
  123.                   {
  124.                      set("\x01",eval("\x01") + 144);
  125.                      ┬º┬ºpush(true);
  126.                   }
  127.                   else
  128.                   {
  129.                      if(eval("\x01") == 253)
  130.                      {
  131.                         set("\x01",eval("\x01") - 9);
  132.                         loop3:
  133.                         while(true)
  134.                         {
  135.                            set(┬º┬ºpop(),┬º┬ºpop() - 393);
  136.                            ┬º┬ºpush(true);
  137.                            while(true)
  138.                            {
  139.                               if(eval("\x01") == 249)
  140.                               {
  141.                                  set("\x01",eval("\x01") + 380);
  142.                                  ┬º┬ºpush(true);
  143.                               }
  144.                               else if(eval("\x01") == 522)
  145.                               {
  146.                                  set("\x01",eval("\x01") + 121);
  147.                                  if(┬º┬ºpop())
  148.                                  {
  149.                                     set("\x01",eval("\x01") + 280);
  150.                                  }
  151.                               }
  152.                               else
  153.                               {
  154.                                  if(eval("\x01") == 716)
  155.                                  {
  156.                                     break;
  157.                                  }
  158.                                  if(eval("\x01") == 696)
  159.                                  {
  160.                                     set("\x01",eval("\x01") - 408);
  161.                                     if(┬º┬ºpop())
  162.                                     {
  163.                                        set("\x01",eval("\x01") + 404);
  164.                                     }
  165.                                  }
  166.                                  else if(eval("\x01") == 629)
  167.                                  {
  168.                                     set("\x01",eval("\x01") - 244);
  169.                                     if(┬º┬ºpop())
  170.                                     {
  171.                                        set("\x01",eval("\x01") - 302);
  172.                                     }
  173.                                  }
  174.                                  else
  175.                                  {
  176.                                     if(eval("\x01") == 127)
  177.                                     {
  178.                                        set("\x01",eval("\x01") + 839);
  179.                                        break loop0;
  180.                                     }
  181.                                     if(eval("\x01") == 699)
  182.                                     {
  183.                                        set("\x01",eval("\x01") - 572);
  184.                                        if(┬º┬ºpop())
  185.                                        {
  186.                                           set("\x01",eval("\x01") + 839);
  187.                                        }
  188.                                     }
  189.                                     else
  190.                                     {
  191.                                        if(eval("\x01") == 89)
  192.                                        {
  193.                                           set("\x01",eval("\x01") + 627);
  194.                                           break loop0;
  195.                                        }
  196.                                        if(eval("\x01") == 339)
  197.                                        {
  198.                                           set("\x01",eval("\x01") - 250);
  199.                                           if(┬º┬ºpop())
  200.                                           {
  201.                                              set("\x01",eval("\x01") + 627);
  202.                                           }
  203.                                        }
  204.                                        else if(eval("\x01") == 923)
  205.                                        {
  206.                                           set("\x01",eval("\x01") - 156);
  207.                                           ┬º┬ºpush(true);
  208.                                        }
  209.                                        else if(eval("\x01") == 569)
  210.                                        {
  211.                                           set("\x01",eval("\x01") - 230);
  212.                                           ┬º┬ºpush(true);
  213.                                        }
  214.                                        else if(eval("\x01") == 323)
  215.                                        {
  216.                                           set("\x01",eval("\x01") + 115);
  217.                                           if(┬º┬ºpop())
  218.                                           {
  219.                                              set("\x01",eval("\x01") - 245);
  220.                                           }
  221.                                        }
  222.                                        else
  223.                                        {
  224.                                           if(eval("\x01") == 385)
  225.                                           {
  226.                                              break loop3;
  227.                                           }
  228.                                           if(eval("\x01") == 881)
  229.                                           {
  230.                                              set("\x01",eval("\x01") - 474);
  231.                                              break loop0;
  232.                                           }
  233.                                           if(eval("\x01") == 83)
  234.                                           {
  235.                                              set("\x01",eval("\x01") + 613);
  236.                                              ┬º┬ºpush(true);
  237.                                           }
  238.                                           else if(eval("\x01") == 692)
  239.                                           {
  240.                                              set("\x01",eval("\x01") - 441);
  241.                                              ┬º┬ºpush(true);
  242.                                           }
  243.                                           else
  244.                                           {
  245.                                              if(eval("\x01") == 530)
  246.                                              {
  247.                                                 set("\x01",eval("\x01") + 39);
  248.                                                 break loop0;
  249.                                              }
  250.                                              if(eval("\x01") == 193)
  251.                                              {
  252.                                                 set("\x01",eval("\x01") - 50);
  253.                                                 ┬º┬ºpush(true);
  254.                                              }
  255.                                              else if(eval("\x01") == 740)
  256.                                              {
  257.                                                 set("\x01",eval("\x01") - 41);
  258.                                                 ┬º┬ºpush(true);
  259.                                              }
  260.                                              else if(eval("\x01") == 966)
  261.                                              {
  262.                                                 set("\x01",eval("\x01") - 444);
  263.                                                 ┬º┬ºpush(true);
  264.                                              }
  265.                                              else
  266.                                              {
  267.                                                 if(eval("\x01") == 288)
  268.                                                 {
  269.                                                    set("\x01",eval("\x01") + 404);
  270.                                                    break loop0;
  271.                                                 }
  272.                                                 if(eval("\x01") == 251)
  273.                                                 {
  274.                                                    set("\x01",eval("\x01") + 279);
  275.                                                    if(┬º┬ºpop())
  276.                                                    {
  277.                                                       set("\x01",eval("\x01") + 39);
  278.                                                    }
  279.                                                 }
  280.                                                 else
  281.                                                 {
  282.                                                    if(eval("\x01") == 438)
  283.                                                    {
  284.                                                       set("\x01",eval("\x01") - 245);
  285.                                                       break loop0;
  286.                                                    }
  287.                                                    if(eval("\x01") == 276)
  288.                                                    {
  289.                                                       set("\x01",eval("\x01") + 464);
  290.                                                       if(┬º┬ºpop())
  291.                                                       {
  292.                                                          set("\x01",eval("\x01") - 720);
  293.                                                       }
  294.                                                       break loop0;
  295.                                                    }
  296.                                                    if(eval("\x01") == 143)
  297.                                                    {
  298.                                                       set("\x01",eval("\x01") + 133);
  299.                                                       if(┬º┬ºpop())
  300.                                                       {
  301.                                                          set("\x01",eval("\x01") + 464);
  302.                                                       }
  303.                                                    }
  304.                                                    else
  305.                                                    {
  306.                                                       if(eval("\x01") == 643)
  307.                                                       {
  308.                                                          set("\x01",eval("\x01") + 280);
  309.                                                          stop();
  310.                                                          break loop0;
  311.                                                       }
  312.                                                       if(eval("\x01") != 767)
  313.                                                       {
  314.                                                          if(eval("\x01") == 407)
  315.                                                          {
  316.                                                             set("\x01",eval("\x01") + 214);
  317.                                                             _root.beamOpen = true;
  318.                                                             _root.energyBar.play();
  319.                                                             break loop0;
  320.                                                          }
  321.                                                          if(eval("\x01") == 621)
  322.                                                          {
  323.                                                             set("\x01",eval("\x01") - 621);
  324.                                                          }
  325.                                                          break loop0;
  326.                                                       }
  327.                                                       set("\x01",eval("\x01") + 114);
  328.                                                       if(┬º┬ºpop())
  329.                                                       {
  330.                                                          set("\x01",eval("\x01") - 474);
  331.                                                       }
  332.                                                    }
  333.                                                 }
  334.                                              }
  335.                                           }
  336.                                        }
  337.                                     }
  338.                                  }
  339.                               }
  340.                            }
  341.                         }
  342.                         set("\x01",eval("\x01") - 302);
  343.                         ┬º┬ºpush(new ┬º\┬º\┬ºpop()┬º());
  344.                         break loop0;
  345.                      }
  346.                      if(eval("\x01") == 290)
  347.                      {
  348.                         set("\x01",eval("\x01") - 221);
  349.                         ┬º┬ºpush(true);
  350.                      }
  351.                      else if(eval("\x01") == 69)
  352.                      {
  353.                         set("\x01",eval("\x01") + 116);
  354.                         if(┬º┬ºpop())
  355.                         {
  356.                            set("\x01",eval("\x01") + 796);
  357.                         }
  358.                      }
  359.                      else
  360.                      {
  361.                         if(eval("\x01") == 822)
  362.                         {
  363.                            set("\x01",eval("\x01") - 455);
  364.                            ┬º┬ºpush(int(┬º┬ºpop()));
  365.                            break loop0;
  366.                         }
  367.                         if(eval("\x01") == 315)
  368.                         {
  369.                            set("\x01",eval("\x01") + 90);
  370.                            if(┬º┬ºpop())
  371.                            {
  372.                               set("\x01",eval("\x01") + 250);
  373.                            }
  374.                         }
  375.                         else
  376.                         {
  377.                            if(eval("\x01") == 128)
  378.                            {
  379.                               set("\x01",eval("\x01") + 162);
  380.                               break loop0;
  381.                            }
  382.                            if(eval("\x01") == 612)
  383.                            {
  384.                               set("\x01",eval("\x01") + 243);
  385.                               ┬º┬ºpush(true);
  386.                            }
  387.                            else
  388.                            {
  389.                               if(eval("\x01") == 540)
  390.                               {
  391.                                  set("\x01",eval("\x01") + 72);
  392.                                  break loop0;
  393.                               }
  394.                               if(eval("\x01") == 244)
  395.                               {
  396.                                  set("\x01",eval("\x01") + 71);
  397.                                  ┬º┬ºpush(true);
  398.                               }
  399.                               else if(eval("\x01") == 867)
  400.                               {
  401.                                  set("\x01",eval("\x01") - 614);
  402.                                  if(┬º┬ºpop())
  403.                                  {
  404.                                     set("\x01",eval("\x01") - 9);
  405.                                  }
  406.                               }
  407.                               else
  408.                               {
  409.                                  if(eval("\x01") == 269)
  410.                                  {
  411.                                     break loop1;
  412.                                  }
  413.                                  if(eval("\x01") == 405)
  414.                                  {
  415.                                     set("\x01",eval("\x01") + 250);
  416.                                     break loop0;
  417.                                  }
  418.                                  if(eval("\x01") == 367)
  419.                                  {
  420.                                     set("\x01",eval("\x01") + 286);
  421.                                     ┬º┬ºpush(true);
  422.                                  }
  423.                                  else
  424.                                  {
  425.                                     if(eval("\x01") == 655)
  426.                                     {
  427.                                        set("\x01",eval("\x01") + 43);
  428.                                        if(_root.sunet)
  429.                                        {
  430.                                           _root.clic2.start(0,1);
  431.                                        }
  432.                                        break loop0;
  433.                                     }
  434.                                     if(eval("\x01") == 647)
  435.                                     {
  436.                                        set("\x01",eval("\x01") - 591);
  437.                                        if(┬º┬ºpop())
  438.                                        {
  439.                                           set("\x01",eval("\x01") + 101);
  440.                                        }
  441.                                     }
  442.                                     else if(eval("\x01") == 675)
  443.                                     {
  444.                                        set("\x01",eval("\x01") - 406);
  445.                                        if(┬º┬ºpop())
  446.                                        {
  447.                                           set("\x01",eval("\x01") - 21);
  448.                                        }
  449.                                     }
  450.                                     else if(eval("\x01") == 981)
  451.                                     {
  452.                                        set("\x01",eval("\x01") - 114);
  453.                                        ┬º┬ºpush(true);
  454.                                     }
  455.                                     else if(eval("\x01") == 855)
  456.                                     {
  457.                                        set("\x01",eval("\x01") - 33);
  458.                                        if(┬º┬ºpop())
  459.                                        {
  460.                                           set("\x01",eval("\x01") - 455);
  461.                                        }
  462.                                     }
  463.                                     else
  464.                                     {
  465.                                        if(eval("\x01") != 392)
  466.                                        {
  467.                                           if(eval("\x01") == 698)
  468.                                           {
  469.                                              set("\x01",eval("\x01") - 698);
  470.                                           }
  471.                                           break loop0;
  472.                                        }
  473.                                        set("\x01",eval("\x01") + 148);
  474.                                        if(┬º┬ºpop())
  475.                                        {
  476.                                           set("\x01",eval("\x01") + 72);
  477.                                        }
  478.                                     }
  479.                                  }
  480.                               }
  481.                            }
  482.                         }
  483.                      }
  484.                   }
  485.                }
  486.             }
  487.          }
  488.          set("\x01",eval("\x01") - 21);
  489.          break;
  490.       }
  491.       if(eval("\x01") == 354)
  492.       {
  493.          set("\x01",eval("\x01") + 351);
  494.          if(┬º┬ºpop())
  495.          {
  496.             set("\x01",eval("\x01") - 21);
  497.          }
  498.          continue;
  499.       }
  500.       if(eval("\x01") == 705)
  501.       {
  502.          set("\x01",eval("\x01") - 21);
  503.          break;
  504.       }
  505.       if(eval("\x01") == 843)
  506.       {
  507.          set("\x01",eval("\x01") + 16);
  508.          if(┬º┬ºpop())
  509.          {
  510.             set("\x01",eval("\x01") + 3);
  511.          }
  512.          continue;
  513.       }
  514.       if(eval("\x01") == 559)
  515.       {
  516.          set("\x01",eval("\x01") - 456);
  517.          ┬º┬ºpush(Number(┬º┬ºpop() | ┬º┬ºpop()));
  518.          break;
  519.       }
  520.       if(eval("\x01") == 684)
  521.       {
  522.          set("\x01",eval("\x01") + 159);
  523.          ┬º┬ºpush(true);
  524.          continue;
  525.       }
  526.       if(eval("\x01") == 558)
  527.       {
  528.          set("\x01",eval("\x01") + 248);
  529.          ┬º┬ºpush(true);
  530.          continue;
  531.       }
  532.       if(eval("\x01") == 922)
  533.       {
  534.          set("\x01",eval("\x01") - 413);
  535.          break;
  536.       }
  537.       if(eval("\x01") == 859)
  538.       {
  539.          set("\x01",eval("\x01") + 3);
  540.          break;
  541.       }
  542.       if(eval("\x01") != 908)
  543.       {
  544.          if(eval("\x01") == 911)
  545.          {
  546.             set("\x01",eval("\x01") - 98);
  547.             ┬º┬ºpush(true);
  548.          }
  549.          else if(eval("\x01") == 813)
  550.          {
  551.             set("\x01",eval("\x01") - 558);
  552.             if(┬º┬ºpop())
  553.             {
  554.                set("\x01",eval("\x01") + 650);
  555.             }
  556.          }
  557.          else if(eval("\x01") == 255)
  558.          {
  559.             set("\x01",eval("\x01") + 656);
  560.          }
  561.          else if(eval("\x01") == 905)
  562.          {
  563.             set("\x01",eval("\x01") - 394);
  564.             ┬º┬ºpush(true);
  565.          }
  566.          else
  567.          {
  568.             if(eval("\x01") == 756)
  569.             {
  570.                set("\x01",eval("\x01") - 198);
  571.                break;
  572.             }
  573.             if(eval("\x01") == 511)
  574.             {
  575.                set("\x01",eval("\x01") - 170);
  576.                if(┬º┬ºpop())
  577.                {
  578.                   set("\x01",eval("\x01") + 442);
  579.                }
  580.             }
  581.             else if(eval("\x01") == 939)
  582.             {
  583.                set("\x01",eval("\x01") - 86);
  584.                if(┬º┬ºpop())
  585.                {
  586.                   set("\x01",eval("\x01") - 637);
  587.                }
  588.             }
  589.             else
  590.             {
  591.                if(eval("\x01") == 341)
  592.                {
  593.                   set("\x01",eval("\x01") + 442);
  594.                   prevFrame();
  595.                   break;
  596.                }
  597.                if(eval("\x01") == 103)
  598.                {
  599.                   set("\x01",eval("\x01") + 836);
  600.                   ┬º┬ºpush(true);
  601.                }
  602.                else
  603.                {
  604.                   if(eval("\x01") != 298)
  605.                   {
  606.                      if(eval("\x01") == 835)
  607.                      {
  608.                         set("\x01",eval("\x01") - 835);
  609.                      }
  610.                      break;
  611.                   }
  612.                   set("\x01",eval("\x01") + 458);
  613.                   if(┬º┬ºpop())
  614.                   {
  615.                      set("\x01",eval("\x01") - 198);
  616.                   }
  617.                }
  618.             }
  619.          }
  620.          continue;
  621.       }
  622.       set("\x01",eval("\x01") + 3);
  623.       loop5:
  624.       while(true)
  625.       {
  626.          while(true)
  627.          {
  628.             if(eval("\x01") == 644)
  629.             {
  630.                set("\x01",eval("\x01") + 219);
  631.                ┬º┬ºpush(true);
  632.                continue;
  633.             }
  634.             if(eval("\x01") == 255)
  635.             {
  636.                set("\x01",eval("\x01") + 474);
  637.                if(┬º┬ºpop())
  638.                {
  639.                   set("\x01",eval("\x01") + 73);
  640.                }
  641.                continue;
  642.             }
  643.             if(eval("\x01") == 451)
  644.             {
  645.                set("\x01",eval("\x01") - 196);
  646.                ┬º┬ºpush(true);
  647.                continue;
  648.             }
  649.             if(eval("\x01") != 538)
  650.             {
  651.                if(eval("\x01") == 272)
  652.                {
  653.                   set("\x01",eval("\x01") + 143);
  654.                   if(_root.sunet)
  655.                   {
  656.                      _root.clic2.start(0,1);
  657.                   }
  658.                   break loop0;
  659.                }
  660.                if(eval("\x01") == 998)
  661.                {
  662.                   set("\x01",eval("\x01") - 460);
  663.                   if(┬º┬ºpop())
  664.                   {
  665.                      set("\x01",eval("\x01") - 266);
  666.                   }
  667.                }
  668.                else if(eval("\x01") == 907)
  669.                {
  670.                   set("\x01",eval("\x01") + 91);
  671.                   ┬º┬ºpush(true);
  672.                }
  673.                else
  674.                {
  675.                   if(eval("\x01") == 945)
  676.                   {
  677.                      set("\x01",eval("\x01") - 38);
  678.                      break loop0;
  679.                   }
  680.                   if(eval("\x01") == 41)
  681.                   {
  682.                      set("\x01",eval("\x01") + 728);
  683.                      break loop0;
  684.                   }
  685.                   if(eval("\x01") == 26)
  686.                   {
  687.                      break;
  688.                   }
  689.                   if(eval("\x01") == 729)
  690.                   {
  691.                      break loop5;
  692.                   }
  693.                   if(eval("\x01") == 113)
  694.                   {
  695.                      set("\x01",eval("\x01") + 832);
  696.                      if(┬º┬ºpop())
  697.                      {
  698.                         set("\x01",eval("\x01") - 38);
  699.                      }
  700.                   }
  701.                   else
  702.                   {
  703.                      if(eval("\x01") == 415)
  704.                      {
  705.                         set("\x01",eval("\x01") - 415);
  706.                         break loop0;
  707.                      }
  708.                      if(eval("\x01") == 194)
  709.                      {
  710.                         set("\x01",eval("\x01") - 153);
  711.                         if(┬º┬ºpop())
  712.                         {
  713.                            set("\x01",eval("\x01") + 728);
  714.                         }
  715.                      }
  716.                      else
  717.                      {
  718.                         if(eval("\x01") == 508)
  719.                         {
  720.                            set("\x01",eval("\x01") - 482);
  721.                            ┬º┬ºpush(┬º┬ºpop() add ┬º┬ºpop());
  722.                            break loop0;
  723.                         }
  724.                         if(eval("\x01") == 802)
  725.                         {
  726.                            set("\x01",eval("\x01") - 608);
  727.                            ┬º┬ºpush(true);
  728.                         }
  729.                         else
  730.                         {
  731.                            if(eval("\x01") == 714)
  732.                            {
  733.                               set("\x01",eval("\x01") - 263);
  734.                               break loop0;
  735.                            }
  736.                            if(eval("\x01") == 863)
  737.                            {
  738.                               set("\x01",eval("\x01") - 149);
  739.                               if(┬º┬ºpop())
  740.                               {
  741.                                  set("\x01",eval("\x01") - 263);
  742.                               }
  743.                            }
  744.                            else if(eval("\x01") == 411)
  745.                            {
  746.                               set("\x01",eval("\x01") + 97);
  747.                               if(┬º┬ºpop())
  748.                               {
  749.                                  set("\x01",eval("\x01") - 482);
  750.                               }
  751.                            }
  752.                            else
  753.                            {
  754.                               if(eval("\x01") != 769)
  755.                               {
  756.                                  break loop0;
  757.                               }
  758.                               set("\x01",eval("\x01") - 358);
  759.                               ┬º┬ºpush(true);
  760.                            }
  761.                         }
  762.                      }
  763.                   }
  764.                }
  765.                continue;
  766.             }
  767.             set("\x01",eval("\x01") - 266);
  768.             loop7:
  769.             while(true)
  770.             {
  771.                loop8:
  772.                while(true)
  773.                {
  774.                   while(true)
  775.                   {
  776.                      if(eval("\x01") == 585)
  777.                      {
  778.                         set("\x01",eval("\x01") + 223);
  779.                         ┬º┬ºpush(true);
  780.                         continue;
  781.                      }
  782.                      if(eval("\x01") == 566)
  783.                      {
  784.                         set("\x01",eval("\x01") - 332);
  785.                         break loop0;
  786.                      }
  787.                      if(eval("\x01") != 836)
  788.                      {
  789.                         if(eval("\x01") == 703)
  790.                         {
  791.                            set("\x01",eval("\x01") - 468);
  792.                            if(_root.sunet)
  793.                            {
  794.                               _root.clic1.start(0,1);
  795.                            }
  796.                            break loop0;
  797.                         }
  798.                         if(eval("\x01") == 48)
  799.                         {
  800.                            set("\x01",eval("\x01") + 655);
  801.                            ┬º┬ºpop();
  802.                            break loop0;
  803.                         }
  804.                         if(eval("\x01") == 808)
  805.                         {
  806.                            set("\x01",eval("\x01") - 242);
  807.                            if(┬º┬ºpop())
  808.                            {
  809.                               set("\x01",eval("\x01") - 332);
  810.                            }
  811.                         }
  812.                         else if(eval("\x01") == 110)
  813.                         {
  814.                            set("\x01",eval("\x01") + 610);
  815.                            ┬º┬ºpush(true);
  816.                         }
  817.                         else if(eval("\x01") == 234)
  818.                         {
  819.                            set("\x01",eval("\x01") + 227);
  820.                            ┬º┬ºpush(true);
  821.                         }
  822.                         else if(eval("\x01") == 461)
  823.                         {
  824.                            set("\x01",eval("\x01") + 375);
  825.                            if(┬º┬ºpop())
  826.                            {
  827.                               set("\x01",eval("\x01") - 726);
  828.                            }
  829.                         }
  830.                         else
  831.                         {
  832.                            if(eval("\x01") == 720)
  833.                            {
  834.                               break;
  835.                            }
  836.                            if(eval("\x01") == 853)
  837.                            {
  838.                               set("\x01",eval("\x01") + 135);
  839.                               if(┬º┬ºpop())
  840.                               {
  841.                                  set("\x01",eval("\x01") - 253);
  842.                               }
  843.                            }
  844.                            else
  845.                            {
  846.                               if(eval("\x01") == 522)
  847.                               {
  848.                                  set("\x01",eval("\x01") - 318);
  849.                                  break loop0;
  850.                               }
  851.                               if(eval("\x01") == 204)
  852.                               {
  853.                                  set("\x01",eval("\x01") + 649);
  854.                                  ┬º┬ºpush(true);
  855.                               }
  856.                               else
  857.                               {
  858.                                  if(eval("\x01") == 988)
  859.                                  {
  860.                                     set("\x01",eval("\x01") - 253);
  861.                                     break loop0;
  862.                                  }
  863.                                  if(eval("\x01") == 735)
  864.                                  {
  865.                                     set("\x01",eval("\x01") - 526);
  866.                                     ┬º┬ºpush(true);
  867.                                  }
  868.                                  else if(eval("\x01") == 209)
  869.                                  {
  870.                                     set("\x01",eval("\x01") + 190);
  871.                                     if(┬º┬ºpop())
  872.                                     {
  873.                                        set("\x01",eval("\x01") - 57);
  874.                                     }
  875.                                  }
  876.                                  else
  877.                                  {
  878.                                     if(eval("\x01") == 399)
  879.                                     {
  880.                                        break loop8;
  881.                                     }
  882.                                     if(eval("\x01") == 235)
  883.                                     {
  884.                                        set("\x01",eval("\x01") - 235);
  885.                                        break loop0;
  886.                                     }
  887.                                     if(eval("\x01") == 342)
  888.                                     {
  889.                                        set("\x01",eval("\x01") + 467);
  890.                                        ┬º┬ºpush(true);
  891.                                     }
  892.                                     else
  893.                                     {
  894.                                        if(eval("\x01") != 809)
  895.                                        {
  896.                                           break loop0;
  897.                                        }
  898.                                        set("\x01",eval("\x01") - 761);
  899.                                        if(┬º┬ºpop())
  900.                                        {
  901.                                           set("\x01",eval("\x01") + 655);
  902.                                        }
  903.                                     }
  904.                                  }
  905.                               }
  906.                            }
  907.                         }
  908.                         continue;
  909.                      }
  910.                      set("\x01",eval("\x01") - 726);
  911.                      loop10:
  912.                      while(true)
  913.                      {
  914.                         if(┬º┬ºpop() == 934)
  915.                         {
  916.                            set("\x01",eval("\x01") - 36);
  917.                            break loop0;
  918.                         }
  919.                         if(eval("\x01") == 951)
  920.                         {
  921.                            set("\x01",eval("\x01") - 17);
  922.                            if(┬º┬ºpop())
  923.                            {
  924.                               set("\x01",eval("\x01") - 36);
  925.                            }
  926.                         }
  927.                         else if(eval("\x01") == 122)
  928.                         {
  929.                            set("\x01",eval("\x01") + 378);
  930.                            ┬º┬ºpush(true);
  931.                         }
  932.                         else
  933.                         {
  934.                            if(eval("\x01") == 801)
  935.                            {
  936.                               set("\x01",eval("\x01") - 679);
  937.                               ┬º┬ºpop()[┬º┬ºpop()] = eval(┬º┬ºpop())[┬º┬ºconstant(16)][┬º┬ºconstant(12)];
  938.                               _root[┬º┬ºconstant(11)] = clic2[┬º┬ºconstant(16)][┬º┬ºconstant(11)] - 10;
  939.                               _root[┬º┬ºconstant(19)][┬º┬ºconstant(18)]();
  940.                               _root[┬º┬ºconstant(8)](┬º┬ºconstant(20));
  941.                               _root[┬º┬ºconstant(10)] = 0;
  942.                               _root[┬º┬ºconstant(11)] += _root[┬º┬ºconstant(10)];
  943.                               _root[┬º┬ºconstant(9)] = 100;
  944.                               if(_root[┬º┬ºconstant(11)] >= 500)
  945.                               {
  946.                                  removeMovieClip(_root);
  947.                               }
  948.                               break loop0;
  949.                            }
  950.                            if(eval("\x01") == 599)
  951.                            {
  952.                               set("\x01",eval("\x01") + 70);
  953.                               if(┬º┬ºpop())
  954.                               {
  955.                                  set("\x01",eval("\x01") - 275);
  956.                               }
  957.                            }
  958.                            else if(eval("\x01") == 13)
  959.                            {
  960.                               set("\x01",eval("\x01") + 788);
  961.                               if(┬º┬ºpop())
  962.                               {
  963.                                  set("\x01",eval("\x01") - 679);
  964.                               }
  965.                            }
  966.                            else if(eval("\x01") == 689)
  967.                            {
  968.                               set("\x01",eval("\x01") - 676);
  969.                               ┬º┬ºpush(true);
  970.                            }
  971.                            else
  972.                            {
  973.                               if(eval("\x01") != 255)
  974.                               {
  975.                                  if(eval("\x01") == 821)
  976.                                  {
  977.                                     set("\x01",eval("\x01") - 132);
  978.                                  }
  979.                                  break loop0;
  980.                               }
  981.                               set("\x01",eval("\x01") + 566);
  982.                               if(┬º┬ºpop())
  983.                               {
  984.                                  set("\x01",eval("\x01") - 132);
  985.                               }
  986.                            }
  987.                         }
  988.                         while(true)
  989.                         {
  990.                            if(eval("\x01") == 239)
  991.                            {
  992.                               set("\x01",eval("\x01") + 360);
  993.                               ┬º┬ºpush(true);
  994.                               continue;
  995.                            }
  996.                            if(eval("\x01") == 686)
  997.                            {
  998.                               set("\x01",eval("\x01") + 300);
  999.                               if(┬º┬ºpop())
  1000.                               {
  1001.                                  set("\x01",eval("\x01") - 863);
  1002.                               }
  1003.                               continue;
  1004.                            }
  1005.                            if(eval("\x01") == 827)
  1006.                            {
  1007.                               set("\x01",eval("\x01") - 141);
  1008.                               ┬º┬ºpush(true);
  1009.                               continue;
  1010.                            }
  1011.                            if(eval("\x01") == 985)
  1012.                            {
  1013.                               set("\x01",eval("\x01") - 927);
  1014.                               break loop0;
  1015.                            }
  1016.                            if(eval("\x01") == 986)
  1017.                            {
  1018.                               set("\x01",eval("\x01") - 863);
  1019.                               break loop0;
  1020.                            }
  1021.                            if(eval("\x01") == 378)
  1022.                            {
  1023.                               set("\x01",eval("\x01") + 435);
  1024.                               ┬º┬ºpush(true);
  1025.                               continue;
  1026.                            }
  1027.                            if(eval("\x01") == 813)
  1028.                            {
  1029.                               set("\x01",eval("\x01") + 172);
  1030.                               if(┬º┬ºpop())
  1031.                               {
  1032.                                  set("\x01",eval("\x01") - 927);
  1033.                               }
  1034.                               continue;
  1035.                            }
  1036.                            if(eval("\x01") == 732)
  1037.                            {
  1038.                               set("\x01",eval("\x01") - 544);
  1039.                               if(┬º┬ºpop())
  1040.                               {
  1041.                                  set("\x01",eval("\x01") + 639);
  1042.                               }
  1043.                               continue;
  1044.                            }
  1045.                            if(eval("\x01") == 123)
  1046.                            {
  1047.                               set("\x01",eval("\x01") + 284);
  1048.                               stop();
  1049.                               break loop0;
  1050.                            }
  1051.                            if(eval("\x01") == 974)
  1052.                            {
  1053.                               set("\x01",eval("\x01") - 23);
  1054.                               ┬º┬ºpush(true);
  1055.                               continue;
  1056.                            }
  1057.                            if(eval("\x01") == 394)
  1058.                            {
  1059.                               set("\x01",eval("\x01") - 139);
  1060.                               ┬º┬ºpush(true);
  1061.                               continue;
  1062.                            }
  1063.                            if(eval("\x01") == 188)
  1064.                            {
  1065.                               set("\x01",eval("\x01") + 639);
  1066.                               break loop0;
  1067.                            }
  1068.                            if(eval("\x01") == 58)
  1069.                            {
  1070.                               set("\x01",eval("\x01") + 674);
  1071.                               ┬º┬ºpush(true);
  1072.                               continue;
  1073.                            }
  1074.                            if(eval("\x01") == 140)
  1075.                            {
  1076.                               set("\x01",eval("\x01") + 238);
  1077.                               ┬º┬ºpush(!!┬º┬ºpop());
  1078.                               break loop0;
  1079.                            }
  1080.                            if(eval("\x01") == 500)
  1081.                            {
  1082.                               set("\x01",eval("\x01") + 408);
  1083.                               if(┬º┬ºpop())
  1084.                               {
  1085.                                  set("\x01",eval("\x01") + 66);
  1086.                               }
  1087.                               continue;
  1088.                            }
  1089.                            if(eval("\x01") == 669)
  1090.                            {
  1091.                               set("\x01",eval("\x01") - 275);
  1092.                               break loop0;
  1093.                            }
  1094.                            if(eval("\x01") == 908)
  1095.                            {
  1096.                               break;
  1097.                            }
  1098.                            if(eval("\x01") == 922)
  1099.                            {
  1100.                               set("\x01",eval("\x01") - 782);
  1101.                               if(┬º┬ºpop())
  1102.                               {
  1103.                                  set("\x01",eval("\x01") + 238);
  1104.                               }
  1105.                               continue;
  1106.                            }
  1107.                            if(eval("\x01") == 898)
  1108.                            {
  1109.                               set("\x01",eval("\x01") + 24);
  1110.                               ┬º┬ºpush(true);
  1111.                               continue;
  1112.                            }
  1113.                            if(eval("\x01") == 407)
  1114.                            {
  1115.                               set("\x01",eval("\x01") - 407);
  1116.                               break loop0;
  1117.                            }
  1118.                            continue loop10;
  1119.                         }
  1120.                         set("\x01",eval("\x01") + 66);
  1121.                         throw ┬º┬ºpop() - typeof ┬º┬ºpop();
  1122.                      }
  1123.                   }
  1124.                   set("\x01",eval("\x01") - 198);
  1125.                   if(!┬º┬ºpop())
  1126.                   {
  1127.                      continue loop7;
  1128.                   }
  1129.                   set("\x01",eval("\x01") - 318);
  1130.                }
  1131.                set("\x01",eval("\x01") - 57);
  1132.                prevFrame();
  1133.                break loop0;
  1134.             }
  1135.          }
  1136.          set("\x01",eval("\x01") + 87);
  1137.       }
  1138.       set("\x01",eval("\x01") + 73);
  1139.       while(true)
  1140.       {
  1141.          if(┬º┬ºpop() == 904)
  1142.          {
  1143.             set("\x01",eval("\x01") - 609);
  1144.             if(┬º┬ºpop())
  1145.             {
  1146.                set("\x01",eval("\x01") + 473);
  1147.             }
  1148.          }
  1149.          else if(eval("\x01") == 197)
  1150.          {
  1151.             set("\x01",eval("\x01") + 739);
  1152.             ┬º┬ºpush(true);
  1153.          }
  1154.          else if(eval("\x01") == 768)
  1155.          {
  1156.             set("\x01",eval("\x01") - 140);
  1157.             ┬º┬ºpush(true);
  1158.          }
  1159.          else
  1160.          {
  1161.             if(eval("\x01") == 211)
  1162.             {
  1163.                set("\x01",eval("\x01") + 774);
  1164.                break loop0;
  1165.             }
  1166.             if(eval("\x01") == 736)
  1167.             {
  1168.                set("\x01",eval("\x01") - 158);
  1169.                if(┬º┬ºpop())
  1170.                {
  1171.                   set("\x01",eval("\x01") + 104);
  1172.                }
  1173.             }
  1174.             else
  1175.             {
  1176.                if(eval("\x01") == 121)
  1177.                {
  1178.                   set("\x01",eval("\x01") + 386);
  1179.                   _loc1_[┬º┬ºconstant(6)][┬º┬ºconstant(7)](┬º┬ºpop() >> ┬º┬ºpop());
  1180.                   ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  1181.                   break loop0;
  1182.                }
  1183.                if(eval("\x01") == 682)
  1184.                {
  1185.                   set("\x01",eval("\x01") + 37);
  1186.                   ┬º┬ºpush(true);
  1187.                }
  1188.                else
  1189.                {
  1190.                   if(eval("\x01") == 295)
  1191.                   {
  1192.                      set("\x01",eval("\x01") + 473);
  1193.                      break loop0;
  1194.                   }
  1195.                   if(eval("\x01") == 255)
  1196.                   {
  1197.                      set("\x01",eval("\x01") + 616);
  1198.                      ┬º┬ºpush(true);
  1199.                   }
  1200.                   else if(eval("\x01") == 643)
  1201.                   {
  1202.                      set("\x01",eval("\x01") - 491);
  1203.                      ┬º┬ºpush(true);
  1204.                   }
  1205.                   else
  1206.                   {
  1207.                      if(eval("\x01") == 743)
  1208.                      {
  1209.                         set("\x01",eval("\x01") - 488);
  1210.                         prevFrame();
  1211.                         break loop0;
  1212.                      }
  1213.                      if(eval("\x01") == 732)
  1214.                      {
  1215.                         set("\x01",eval("\x01") - 89);
  1216.                         break loop0;
  1217.                      }
  1218.                      if(eval("\x01") == 871)
  1219.                      {
  1220.                         set("\x01",eval("\x01") - 421);
  1221.                         if(┬º┬ºpop())
  1222.                         {
  1223.                            set("\x01",eval("\x01") - 222);
  1224.                         }
  1225.                      }
  1226.                      else if(eval("\x01") == 751)
  1227.                      {
  1228.                         set("\x01",eval("\x01") - 135);
  1229.                         ┬º┬ºpush(true);
  1230.                      }
  1231.                      else
  1232.                      {
  1233.                         if(eval("\x01") == 450)
  1234.                         {
  1235.                            set("\x01",eval("\x01") - 222);
  1236.                            break loop0;
  1237.                         }
  1238.                         if(eval("\x01") == 218)
  1239.                         {
  1240.                            set("\x01",eval("\x01") + 544);
  1241.                            if(┬º┬ºpop()[┬º┬ºpop()]())
  1242.                            {
  1243.                               _root[┬º┬ºconstant(8)](┬º┬ºconstant(7));
  1244.                               _root[┬º┬ºconstant(9)] = 80;
  1245.                               _root[┬º┬ºconstant(10)] = 0;
  1246.                               _root[┬º┬ºconstant(11)] = clic2.start[┬º┬ºconstant(11)] + 60;
  1247.                               _root[┬º┬ºconstant(12)] = clic2.start[┬º┬ºconstant(12)];
  1248.                            }
  1249.                            else if(clic2[┬º┬ºconstant(13)][┬º┬ºconstant(6)](_root[┬º┬ºconstant(12)],_root[┬º┬ºconstant(11)],true) && !_root[┬º┬ºconstant(6)](clic2.start[┬º┬ºconstant(4)][┬º┬ºconstant(5)]) && _root[┬º┬ºconstant(14)] == false)
  1250.                            {
  1251.                               if(clic2[┬º┬ºconstant(13)][┬º┬ºconstant(6)](_root[┬º┬ºconstant(12)],_root[┬º┬ºconstant(11)] - 3,true) && !_root[┬º┬ºconstant(6)](clic2.start[┬º┬ºconstant(4)][┬º┬ºconstant(5)]))
  1252.                               {
  1253.                                  _root[┬º┬ºconstant(11)] -= 2;
  1254.                                  _root[┬º┬ºconstant(8)](┬º┬ºconstant(15));
  1255.                               }
  1256.                               else
  1257.                               {
  1258.                                  if(_root[┬º┬ºconstant(5)][┬º┬ºconstant(6)](clic2[┬º┬ºconstant(16)][┬º┬ºconstant(5)]) && eval(┬º┬ºconstant(17)) == 0)
  1259.                                  {
  1260.                                     clic2[┬º┬ºconstant(16)][┬º┬ºconstant(4)][┬º┬ºconstant(18)]();
  1261.                                     _root[┬º┬ºconstant(12)] = clic2[┬º┬ºconstant(16)][┬º┬ºconstant(12)];
  1262.                                     _root[┬º┬ºconstant(11)] = clic2[┬º┬ºconstant(16)][┬º┬ºconstant(11)] - 10;
  1263.                                     _root[┬º┬ºconstant(19)][┬º┬ºconstant(18)]();
  1264.                                  }
  1265.                                  _root[┬º┬ºconstant(8)](┬º┬ºconstant(20));
  1266.                                  _root[┬º┬ºconstant(10)] = 0;
  1267.                                  _root[┬º┬ºconstant(11)] += _root[┬º┬ºconstant(10)];
  1268.                                  _root[┬º┬ºconstant(9)] = 100;
  1269.                               }
  1270.                            }
  1271.                            else if(!clic2[┬º┬ºconstant(13)][┬º┬ºconstant(6)](_root[┬º┬ºconstant(12)],_root[┬º┬ºconstant(11)],true))
  1272.                            {
  1273.                               _root[┬º┬ºconstant(8)](┬º┬ºconstant(21));
  1274.                               _root[┬º┬ºconstant(9)] = 100;
  1275.                               _root[┬º┬ºconstant(10)] += 0.3;
  1276.                               _root[┬º┬ºconstant(11)] += _root[┬º┬ºconstant(10)];
  1277.                            }
  1278.                            else if(_root[┬º┬ºconstant(14)] == true)
  1279.                            {
  1280.                               _root[┬º┬ºconstant(8)](┬º┬ºconstant(22));
  1281.                            }
  1282.                            if(_root[┬º┬ºconstant(11)] >= 500)
  1283.                            {
  1284.                               clic2[┬º┬ºconstant(23)]--;
  1285.                               if(clic2[┬º┬ºconstant(24)] >= clic2[┬º┬ºconstant(25)])
  1286.                               {
  1287.                                  clic2[┬º┬ºconstant(26)][┬º┬ºconstant(27)](2);
  1288.                               }
  1289.                               else if(clic2[┬º┬ºconstant(23)] == 0 && clic2[┬º┬ºconstant(24)] >= 1)
  1290.                               {
  1291.                                  clic2[┬º┬ºconstant(26)][┬º┬ºconstant(27)](2);
  1292.                               }
  1293.                               else if(energyBar[┬º┬ºconstant(23)] == 0)
  1294.                               {
  1295.                                  energyBar[┬º┬ºconstant(26)][┬º┬ºconstant(27)](┬º┬ºconstant(28));
  1296.                               }
  1297.                               removeMovieClip(_root);
  1298.                            }
  1299.                            break loop0;
  1300.                         }
  1301.                         if(eval("\x01") == 762)
  1302.                         {
  1303.                            set("\x01",eval("\x01") + 142);
  1304.                            ┬º┬ºpush(true);
  1305.                         }
  1306.                         else if(eval("\x01") == 228)
  1307.                         {
  1308.                            set("\x01",eval("\x01") + 508);
  1309.                            ┬º┬ºpush(true);
  1310.                         }
  1311.                         else
  1312.                         {
  1313.                            if(eval("\x01") == 578)
  1314.                            {
  1315.                               set("\x01",eval("\x01") + 104);
  1316.                               break loop0;
  1317.                            }
  1318.                            if(eval("\x01") == 628)
  1319.                            {
  1320.                               set("\x01",eval("\x01") - 547);
  1321.                               if(┬º┬ºpop())
  1322.                               {
  1323.                                  set("\x01",eval("\x01") + 670);
  1324.                               }
  1325.                            }
  1326.                            else if(eval("\x01") == 719)
  1327.                            {
  1328.                               set("\x01",eval("\x01") - 598);
  1329.                               if(┬º┬ºpop())
  1330.                               {
  1331.                                  set("\x01",eval("\x01") + 386);
  1332.                               }
  1333.                            }
  1334.                            else if(eval("\x01") == 616)
  1335.                            {
  1336.                               set("\x01",eval("\x01") - 339);
  1337.                               if(┬º┬ºpop())
  1338.                               {
  1339.                                  set("\x01",eval("\x01") - 80);
  1340.                               }
  1341.                            }
  1342.                            else if(eval("\x01") == 277)
  1343.                            {
  1344.                               set("\x01",eval("\x01") - 80);
  1345.                               stop();
  1346.                               while(true)
  1347.                               {
  1348.                                  if(┬º┬ºpop())
  1349.                                  {
  1350.                                     set("\x01",eval("\x01") - 157);
  1351.                                     ┬º┬ºpush(true);
  1352.                                  }
  1353.                                  else if(eval("\x01") == 267)
  1354.                                  {
  1355.                                     set("\x01",eval("\x01") - 35);
  1356.                                     if(┬º┬ºpop())
  1357.                                     {
  1358.                                        set("\x01",eval("\x01") + 424);
  1359.                                     }
  1360.                                  }
  1361.                                  else if(eval("\x01") == 766)
  1362.                                  {
  1363.                                     set("\x01",eval("\x01") + 15);
  1364.                                     if(┬º┬ºpop())
  1365.                                     {
  1366.                                        set("\x01",eval("\x01") - 164);
  1367.                                     }
  1368.                                  }
  1369.                                  else
  1370.                                  {
  1371.                                     if(eval("\x01") == 232)
  1372.                                     {
  1373.                                        set("\x01",eval("\x01") + 424);
  1374.                                        var ┬º┬ºpop();
  1375.                                        ┬º┬ºpush(new ┬º┬ºpop()[┬º┬ºpop() >> ┬º┬ºpop()]());
  1376.                                        break loop0;
  1377.                                     }
  1378.                                     if(eval("\x01") == 247)
  1379.                                     {
  1380.                                        set("\x01",eval("\x01") - 247);
  1381.                                        break loop0;
  1382.                                     }
  1383.                                     if(eval("\x01") != 499)
  1384.                                     {
  1385.                                        break loop0;
  1386.                                     }
  1387.                                     set("\x01",eval("\x01") - 342);
  1388.                                     if(┬º┬ºpop())
  1389.                                     {
  1390.                                        set("\x01",eval("\x01") + 31);
  1391.                                     }
  1392.                                  }
  1393.                                  while(true)
  1394.                                  {
  1395.                                     if(eval("\x01") == 460)
  1396.                                     {
  1397.                                        set("\x01",eval("\x01") - 175);
  1398.                                        ┬º┬ºpush(true);
  1399.                                     }
  1400.                                     else if(eval("\x01") == 669)
  1401.                                     {
  1402.                                        set("\x01",eval("\x01") + 53);
  1403.                                        if(┬º┬ºpop())
  1404.                                        {
  1405.                                           set("\x01",eval("\x01") - 199);
  1406.                                        }
  1407.                                     }
  1408.                                     else
  1409.                                     {
  1410.                                        if(eval("\x01") == 523)
  1411.                                        {
  1412.                                           set("\x01",eval("\x01") - 276);
  1413.                                           _root.speedY = 1;
  1414.                                           break loop0;
  1415.                                        }
  1416.                                        if(eval("\x01") == 188)
  1417.                                        {
  1418.                                           set("\x01",eval("\x01") + 578);
  1419.                                           ┬º┬ºpush(true);
  1420.                                        }
  1421.                                        else
  1422.                                        {
  1423.                                           if(eval("\x01") == 781)
  1424.                                           {
  1425.                                              set("\x01",eval("\x01") - 164);
  1426.                                              break loop0;
  1427.                                           }
  1428.                                           if(eval("\x01") == 157)
  1429.                                           {
  1430.                                              set("\x01",eval("\x01") + 31);
  1431.                                              break loop0;
  1432.                                           }
  1433.                                           if(eval("\x01") == 722)
  1434.                                           {
  1435.                                              set("\x01",eval("\x01") - 199);
  1436.                                              loop16:
  1437.                                              while(true)
  1438.                                              {
  1439.                                                 set(┬º┬ºpop(),eval("\x01") - 355);
  1440.                                                 ┬º┬ºpush(true);
  1441.                                                 while(true)
  1442.                                                 {
  1443.                                                    if(eval("\x01") == 414)
  1444.                                                    {
  1445.                                                       set("\x01",eval("\x01") + 571);
  1446.                                                       ┬º┬ºpush(true);
  1447.                                                    }
  1448.                                                    else if(eval("\x01") == 965)
  1449.                                                    {
  1450.                                                       set("\x01",eval("\x01") - 187);
  1451.                                                       if(┬º┬ºpop())
  1452.                                                       {
  1453.                                                          set("\x01",eval("\x01") - 69);
  1454.                                                       }
  1455.                                                    }
  1456.                                                    else if(eval("\x01") == 742)
  1457.                                                    {
  1458.                                                       set("\x01",eval("\x01") - 319);
  1459.                                                       if(┬º┬ºpop())
  1460.                                                       {
  1461.                                                          set("\x01",eval("\x01") + 148);
  1462.                                                       }
  1463.                                                    }
  1464.                                                    else if(eval("\x01") == 571)
  1465.                                                    {
  1466.                                                       set("\x01",eval("\x01") - 289);
  1467.                                                       ┬º┬ºpush(true);
  1468.                                                    }
  1469.                                                    else if(eval("\x01") == 517)
  1470.                                                    {
  1471.                                                       set("\x01",eval("\x01") + 271);
  1472.                                                       if(┬º┬ºpop())
  1473.                                                       {
  1474.                                                          set("\x01",eval("\x01") + 40);
  1475.                                                       }
  1476.                                                    }
  1477.                                                    else if(eval("\x01") == 828)
  1478.                                                    {
  1479.                                                       set("\x01",eval("\x01") - 488);
  1480.                                                       ┬º┬ºpush(true);
  1481.                                                    }
  1482.                                                    else
  1483.                                                    {
  1484.                                                       if(eval("\x01") == 509)
  1485.                                                       {
  1486.                                                          break;
  1487.                                                       }
  1488.                                                       if(eval("\x01") == 134)
  1489.                                                       {
  1490.                                                          set("\x01",eval("\x01") + 269);
  1491.                                                          if(┬º┬ºpop())
  1492.                                                          {
  1493.                                                             set("\x01",eval("\x01") - 337);
  1494.                                                          }
  1495.                                                       }
  1496.                                                       else if(eval("\x01") == 985)
  1497.                                                       {
  1498.                                                          set("\x01",eval("\x01") - 135);
  1499.                                                          if(┬º┬ºpop())
  1500.                                                          {
  1501.                                                             set("\x01",eval("\x01") - 341);
  1502.                                                          }
  1503.                                                       }
  1504.                                                       else if(eval("\x01") == 618)
  1505.                                                       {
  1506.                                                          set("\x01",eval("\x01") - 132);
  1507.                                                          ┬º┬ºpush(true);
  1508.                                                       }
  1509.                                                       else if(eval("\x01") == 282)
  1510.                                                       {
  1511.                                                          set("\x01",eval("\x01") - 130);
  1512.                                                          if(┬º┬ºpop())
  1513.                                                          {
  1514.                                                             set("\x01",eval("\x01") + 505);
  1515.                                                          }
  1516.                                                       }
  1517.                                                       else if(eval("\x01") == 860)
  1518.                                                       {
  1519.                                                          set("\x01",eval("\x01") - 118);
  1520.                                                          ┬º┬ºpush(true);
  1521.                                                       }
  1522.                                                       else if(eval("\x01") == 709)
  1523.                                                       {
  1524.                                                          set("\x01",eval("\x01") - 192);
  1525.                                                          ┬º┬ºpush(true);
  1526.                                                       }
  1527.                                                       else if(eval("\x01") == 154)
  1528.                                                       {
  1529.                                                          set("\x01",eval("\x01") + 651);
  1530.                                                          if(┬º┬ºpop())
  1531.                                                          {
  1532.                                                             set("\x01",eval("\x01") + 55);
  1533.                                                          }
  1534.                                                       }
  1535.                                                       else
  1536.                                                       {
  1537.                                                          if(eval("\x01") == 451)
  1538.                                                          {
  1539.                                                             set("\x01",eval("\x01") - 254);
  1540.                                                             set("\x01",eval("\x01") + 279);
  1541.                                                             var ┬º┬ºpop();
  1542.                                                             break loop0;
  1543.                                                          }
  1544.                                                          if(eval("\x01") == 657)
  1545.                                                          {
  1546.                                                             set("\x01",eval("\x01") - 523);
  1547.                                                             ┬º┬ºpush(true);
  1548.                                                          }
  1549.                                                          else
  1550.                                                          {
  1551.                                                             if(eval("\x01") == 152)
  1552.                                                             {
  1553.                                                                set("\x01",eval("\x01") + 505);
  1554.                                                                break loop0;
  1555.                                                             }
  1556.                                                             if(eval("\x01") == 486)
  1557.                                                             {
  1558.                                                                set("\x01",eval("\x01") - 35);
  1559.                                                                if(┬º┬ºpop())
  1560.                                                                {
  1561.                                                                   set("\x01",eval("\x01") - 254);
  1562.                                                                }
  1563.                                                             }
  1564.                                                             else
  1565.                                                             {
  1566.                                                                if(eval("\x01") == 850)
  1567.                                                                {
  1568.                                                                   break loop16;
  1569.                                                                }
  1570.                                                                if(eval("\x01") == 112)
  1571.                                                                {
  1572.                                                                   set("\x01",eval("\x01") + 506);
  1573.                                                                   break loop0;
  1574.                                                                }
  1575.                                                                if(eval("\x01") == 805)
  1576.                                                                {
  1577.                                                                   set("\x01",eval("\x01") + 55);
  1578.                                                                   break loop0;
  1579.                                                                }
  1580.                                                                if(eval("\x01") == 423)
  1581.                                                                {
  1582.                                                                   set("\x01",eval("\x01") + 148);
  1583.                                                                   break loop0;
  1584.                                                                }
  1585.                                                                if(eval("\x01") == 403)
  1586.                                                                {
  1587.                                                                   set("\x01",eval("\x01") - 337);
  1588.                                                                   break loop0;
  1589.                                                                }
  1590.                                                                if(eval("\x01") == 778)
  1591.                                                                {
  1592.                                                                   set("\x01",eval("\x01") - 69);
  1593.                                                                   break loop0;
  1594.                                                                }
  1595.                                                                if(eval("\x01") == 0)
  1596.                                                                {
  1597.                                                                   set("\x01",eval("\x01") + 965);
  1598.                                                                   ┬º┬ºpush(true);
  1599.                                                                }
  1600.                                                                else if(eval("\x01") == 66)
  1601.                                                                {
  1602.                                                                   set("\x01",eval("\x01") + 673);
  1603.                                                                   ┬º┬ºpush(true);
  1604.                                                                }
  1605.                                                                else if(eval("\x01") == 340)
  1606.                                                                {
  1607.                                                                   set("\x01",eval("\x01") - 228);
  1608.                                                                   if(┬º┬ºpop())
  1609.                                                                   {
  1610.                                                                      set("\x01",eval("\x01") + 506);
  1611.                                                                   }
  1612.                                                                }
  1613.                                                                else
  1614.                                                                {
  1615.                                                                   if(eval("\x01") != 739)
  1616.                                                                   {
  1617.                                                                      if(eval("\x01") == 897)
  1618.                                                                      {
  1619.                                                                         set("\x01",eval("\x01") - 897);
  1620.                                                                         prevFrame();
  1621.                                                                         break loop0;
  1622.                                                                      }
  1623.                                                                      if(eval("\x01") == 788)
  1624.                                                                      {
  1625.                                                                         set("\x01",eval("\x01") + 40);
  1626.                                                                         break loop0;
  1627.                                                                      }
  1628.                                                                      if(eval("\x01") == 197)
  1629.                                                                      {
  1630.                                                                         set("\x01",eval("\x01") + 594);
  1631.                                                                         _root.beamOpen = false;
  1632.                                                                         _root.float = false;
  1633.                                                                         stop();
  1634.                                                                         break loop0;
  1635.                                                                      }
  1636.                                                                      if(eval("\x01") == 791)
  1637.                                                                      {
  1638.                                                                         set("\x01",eval("\x01") - 791);
  1639.                                                                      }
  1640.                                                                      break loop0;
  1641.                                                                   }
  1642.                                                                   set("\x01",eval("\x01") + 158);
  1643.                                                                   if(┬º┬ºpop())
  1644.                                                                   {
  1645.                                                                      set("\x01",eval("\x01") - 897);
  1646.                                                                   }
  1647.                                                                }
  1648.                                                             }
  1649.                                                          }
  1650.                                                       }
  1651.                                                    }
  1652.                                                 }
  1653.                                              }
  1654.                                              set("\x01",eval("\x01") - 341);
  1655.                                              break loop0;
  1656.                                           }
  1657.                                           if(eval("\x01") == 285)
  1658.                                           {
  1659.                                              set("\x01",eval("\x01") + 340);
  1660.                                              if(┬º┬ºpop())
  1661.                                              {
  1662.                                                 set("\x01",eval("\x01") - 451);
  1663.                                              }
  1664.                                           }
  1665.                                           else
  1666.                                           {
  1667.                                              if(eval("\x01") == 625)
  1668.                                              {
  1669.                                                 set("\x01",eval("\x01") - 451);
  1670.                                                 ┬º┬ºpush(┬º┬ºpop() >> (┬º┬ºpop() >>> ┬º┬ºpop()));
  1671.                                                 break loop0;
  1672.                                              }
  1673.                                              if(eval("\x01") == 174)
  1674.                                              {
  1675.                                                 set("\x01",eval("\x01") + 93);
  1676.                                                 ┬º┬ºpush(true);
  1677.                                              }
  1678.                                              else
  1679.                                              {
  1680.                                                 if(eval("\x01") != 617)
  1681.                                                 {
  1682.                                                    break;
  1683.                                                 }
  1684.                                                 set("\x01",eval("\x01") + 52);
  1685.                                                 ┬º┬ºpush(true);
  1686.                                              }
  1687.                                           }
  1688.                                        }
  1689.                                     }
  1690.                                  }
  1691.                               }
  1692.                            }
  1693.                            else if(eval("\x01") == 507)
  1694.                            {
  1695.                               set("\x01",eval("\x01") - 360);
  1696.                               ┬º┬ºpush(true);
  1697.                            }
  1698.                            else if(eval("\x01") == 936)
  1699.                            {
  1700.                               set("\x01",eval("\x01") - 204);
  1701.                               if(┬º┬ºpop())
  1702.                               {
  1703.                                  set("\x01",eval("\x01") - 89);
  1704.                               }
  1705.                            }
  1706.                            else if(eval("\x01") == 147)
  1707.                            {
  1708.                               set("\x01",eval("\x01") + 71);
  1709.                               if(┬º┬ºpop())
  1710.                               {
  1711.                                  set("\x01",eval("\x01") + 544);
  1712.                               }
  1713.                            }
  1714.                            else
  1715.                            {
  1716.                               if(eval("\x01") != 152)
  1717.                               {
  1718.                                  if(eval("\x01") == 985)
  1719.                                  {
  1720.                                     set("\x01",eval("\x01") - 848);
  1721.                                     stop();
  1722.                                     break loop0;
  1723.                                  }
  1724.                                  if(eval("\x01") == 137)
  1725.                                  {
  1726.                                     set("\x01",eval("\x01") - 137);
  1727.                                  }
  1728.                                  break loop0;
  1729.                               }
  1730.                               set("\x01",eval("\x01") + 59);
  1731.                               if(┬º┬ºpop())
  1732.                               {
  1733.                                  set("\x01",eval("\x01") + 774);
  1734.                               }
  1735.                            }
  1736.                         }
  1737.                      }
  1738.                   }
  1739.                }
  1740.             }
  1741.          }
  1742.          while(true)
  1743.          {
  1744.             if(eval("\x01") == 348)
  1745.             {
  1746.                set("\x01",eval("\x01") - 113);
  1747.                ┬º┬ºpush(true);
  1748.             }
  1749.             else
  1750.             {
  1751.                if(eval("\x01") != 235)
  1752.                {
  1753.                   break;
  1754.                }
  1755.                set("\x01",eval("\x01") + 508);
  1756.                if(┬º┬ºpop())
  1757.                {
  1758.                   set("\x01",eval("\x01") - 488);
  1759.                }
  1760.             }
  1761.          }
  1762.          if(eval("\x01") == 81)
  1763.          {
  1764.             set("\x01",eval("\x01") + 670);
  1765.             break loop0;
  1766.          }
  1767.       }
  1768.    }
  1769. }
  1770.